const express = require('express');
const mongoose = require('mongoose');
const path = require('path');
const fs = require('fs');
const router = express.Router();
const app = express();  // 创建一个 Express 实例

const { userSchemaModel, chuangZuoSchemaModel, zhangJieModel, zhangJiepingluenModel } = require('../model/model');



/* GET home page. */
router.get('/123', function(req, res, next) {
  res.render('index', { title: '成功' });
});


// 添加用户，包括上传头像
router.post('/addUser', async (req, res) => {
  console.log('触发添加addUser');
  try {
    // 从请求体中获取用户信息
    const { username, dengj, shojhao  } = req.body;

    // 处理头像上传
    let avatarFileName = null;
    if (req.files && req.files.avatar) {
      const avatarFile = req.files.avatar;

      // 拆分文件名和文件扩展名
      const fileNameWithoutExtension = avatarFile.name.split('.')[0];
      const fileExtension = avatarFile.name.split('.').pop();
      // 生成时间戳和随机字符串
      const timestamp = new Date().getTime();
      const randomString = Math.random().toString(36).substring(7);
      // 构建新文件名
      avatarFileName = `${fileNameWithoutExtension}_${timestamp}_${randomString}.${fileExtension}`;
      // 构建文件路径
      const avatarFilePath = `./img/avatar/${avatarFileName}`;

      // 创建目标文件夹，如果不存在的话
      const avatarFolderPath = path.dirname(avatarFilePath);
      if (!fs.existsSync(avatarFolderPath)) {
        try {
          fs.mkdirSync(avatarFolderPath, { recursive: true });
        } catch (mkdirError) {
          return res.status(500).json({ error: mkdirError.message });
        }
      }

      // 保存头像文件到服务器
      avatarFile.mv(avatarFilePath, async (err) => {
        if (err) {
          return res.status(500).json({ error: err.message });
        }
      });
    }

    // 创建用户实例，包括头像文件名
    const newUser = new userSchemaModel({
      username,
      dengj,
      shojhao,
      avatar: avatarFileName,
      sex: req.body.sex, // 从请求体中获取性别信息
    });
    console.log(newUser);
    // 保存用户到数据库
    // const savedUser = await newUser.save();
    await newUser.save();

    res.status(200).json({ message: '数据添加成功',code:200 });
  } catch (error) {
    console.error(error);
    res.status(500).json({ message: '内部服务器错误',code:500 });
  }
});




// 获取用户及其头像，
router.get('/getUsertoxiang/:userId', async (req, res) => {
  try {
    const userId = req.params.userId;

    // 使用 mongoose 的 findById 方法查找用户信息
    const user = await userSchemaModel.findById(userId);

    if (!user) {
      return res.status(404).json({ error: 'User not found' });
    }

    // 使用用户的 collections 字段查找关联的创作信息
    const chuangZuoList = await chuangZuoSchemaModel.find({ _id: { $in: user.collections } });

    // 构建包含用户信息和关联创作信息的响应对象
    const responseObj = {
      user: {
        _id: user._id,
        username: user.username,
        dengj: user.dengj,
        sex: user.sex,
        avatar: user.avatar,
        createdAt: user.createdAt,
      },
    };

    // 如果用户有头像，则添加头像二进制数据到响应对象
    if (user.avatar) {
      const imagePath = path.join(__dirname, '..', 'img', 'avatar', user.avatar);
      const imageBuffer = fs.readFileSync(imagePath);
      responseObj.user.avatarImage = imageBuffer;
    }

    res.status(200).json(responseObj);
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});







// 获取用户及其关联的小说信息（这里包含所有头像）
router.get('/getallUsertoxiang/:userId', async (req, res) => {
  try {
    const userId = req.params.userId;

    // 使用 mongoose 的 findById 方法查找用户信息
    const user = await userSchemaModel.findById(userId);

    if (!user) {
      return res.status(404).json({ error: 'User not found' });
    }

    // 使用用户的 collections 字段查找关联的创作信息
    const chuangZuoList = await chuangZuoSchemaModel.find({ weiid: userId });

    // 构建包含用户信息和关联创作信息的响应对象
    const responseObj = {
      user: {
        _id: user._id,
        username: user.username,
        dengj: user.dengj,
        sex: user.sex,
        avatar: user.avatar,
        createdAt: user.createdAt,
      },
      chuangZuoList: chuangZuoList.map(chuangZuo => ({
        _id: chuangZuo._id,
        title: chuangZuo.title,
        content: chuangZuo.content,
        tuavatar: chuangZuo.tuavatar,
        shjian: chuangZuo.shjian,
        fabu: chuangZuo.fabu,
        redu: chuangZuo.redu,
        tuavatarImage: getTuavatarImage(chuangZuo.tuavatar),
      })),
    };

    // 如果用户有头像，则添加头像二进制数据到响应对象
    if (user.avatar) {
      const imagePath = path.join(__dirname, '..', 'img', 'avatar', user.avatar);
      const imageBuffer = fs.readFileSync(imagePath);
      responseObj.user.avatarImage = imageBuffer;
    }

    res.status(200).json(responseObj);
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});

//获取创作图像的二进制数据
function getTuavatarImage(tuavatarFileName) {
  if (!tuavatarFileName) {
    return null;
  }

  const imagePath = path.join(__dirname, '..', 'img', 'shu', tuavatarFileName);
  return fs.readFileSync(imagePath);
}






// 添加章节，weiid也是不能为空要和小说id对应，这是能重复的
router.post('/addZhangJie', async (req, res) => {
  console.log('触发添加 zhangJieModel');
  try {
    // 从请求体中获取章节所需字段
    const { zhangtitle, shu, zhengwen, weiid } = req.body;

    // 检查关联的创作是否存在
    const existingChuangZuo = await chuangZuoSchemaModel.findById(weiid);
    if (!existingChuangZuo) {
      return res.status(400).json({ error: '关联的创作不存在' });
    }

    // 创建新章节实例
    const newZhangJie = new zhangJieModel({
      zhangtitle,
      shu,
      zhengwen,
      weiid,
    });

    // 尝试将新章节保存到数据库
    const savedZhangJie = await newZhangJie.save();

    // 返回成功的响应，包含新章节的信息
    res.status(201).json(savedZhangJie);
  } catch (error) {
    // 捕捉任何错误并返回500内部服务器错误
    console.error(error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});



// 添加章节评论
router.post('/addZhangJiepingluen', async (req, res) => {
  try {
    const { zhangtitle, zhengwen, weiid } = req.body;

    // 检查关联的章节是否存在
    const existingZhangJie = await zhangJieModel.findById(weiid);
    if (!existingZhangJie) {
      return res.status(400).json({ error: '关联的章节不存在' });
    }

    // 创建新的章节评论实例
    const newZhangJiepingluen = new zhangJiepingluenModel({
      zhangtitle,
      weiid,
    });

    // 尝试将新的章节评论保存到数据库
    const savedZhangJiepingluen = await newZhangJiepingluen.save();

    // 返回成功的响应，包含新章节评论的信息
    res.status(201).json(savedZhangJiepingluen);
  } catch (error) {
    // 捕捉任何错误并返回 500 内部服务器错误
    console.error(error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});



//获取每一个章节的评论，这返回的是每一个章节的评论，直接调就行了zhangJieId是章节的id
// http://localhost:3000/sen/getZhangJiePingLuen/659e12ee5fe3ed3e817307c8
router.get('/getZhangJiePingLuen/:zhangJieId', async (req, res) => {
  try {
    const { zhangJieId } = req.params;

    const zhangJiePingLuen = await zhangJiepingluenModel
      .find({ weiid: zhangJieId })
      .populate({
        path: 'weiid',
        select: 'zhangtitle _id'  // 只返回 zhangtitle 和 _id 字段
      });

    res.status(200).json(zhangJiePingLuen);
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});




// 查询所有章节，这是直接获取所有章节没有过滤没有对应的小说，就是单纯的返回所有(一般没什么用)
router.get('/getAllZhangJie', async (req, res) => {
  try {
    const allZhangJie = await zhangJieModel.find();
    res.status(200).json(allZhangJie);
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});



// 小说对应查询所有章节，这里查询到的是所有章节，但他包含每个章节对应的小说，看你们需要，目测没什么用
// http://localhost:3000/sen/getZhangJie
router.get('/getZhangJie', async (req, res) => {
  try {
    const allZhangJie = await zhangJieModel.find().populate('weiid');
    res.status(200).json(allZhangJie);
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});



// 查询创作这就是所有小说，单纯查所有小说，一般写首页的用到，这里返回的数据有头像的
router.get('/getChuangZuo', async (req, res) => {
  console.log('触发查询接口');
  try {
    // 查询数据库中所有创作
    const allChuangZuo = await chuangZuoSchemaModel.find();

    // 转换图片数据为 Base64 格式
    const chuangZuoWithBase64 = await Promise.all(allChuangZuo.map(async chuangZuo => {
      const imagePath = path.join(__dirname, '..', 'img', 'shu', chuangZuo.tuavatar);
      const tuavatarBase64 = await getBase64FromImagePath(imagePath);
      
      return {
        _id: chuangZuo._id,
        title: chuangZuo.title,
        content: chuangZuo.content,
        tuavatar: chuangZuo.tuavatar,
        shjian: chuangZuo.shjian,
        fabu: chuangZuo.fabu,
        redu: chuangZuo.redu,
        weiid: chuangZuo.weiid,
        // 将图片数据转为 Base64
        tuavatarBase64,
      };
    }));

    // 返回所有创作的信息，包括图片的 Base64 格式
    res.status(200).json(chuangZuoWithBase64);
  } catch (error) {
    // 捕捉任何错误并返回500内部服务器错误
    console.error(error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});

// 获取图片的 Base64 数据
function getBase64FromImagePath(imagePath) {
  return new Promise((resolve, reject) => {
    fs.readFile(imagePath, (err, data) => {
      if (err) {
        reject(err);
      } else {
        resolve(data.toString('base64'));
      }
    });
  });
}




// 查询所有创作,这里包含用户信息和对应用户的小说，注意这里返回的信息里面有用户信息
router.get('/getallallChuangZuo', async (req, res) => {
  console.log('触发查询接口');
  try {

    const allChuangZuo = await chuangZuoSchemaModel.find();


    const chuangZuoWithBase64AndUser = await Promise.all(allChuangZuo.map(async chuangZuo => {
      const imagePath = path.join(__dirname, '..', 'img', 'shu', chuangZuo.tuavatar);
      const tuavatarBase64 = await getBase64FromImagePath(imagePath);

      // 查询关联的用户信息
      const user = await userSchemaModel.findById(chuangZuo.weiid);

      return {
        _id: chuangZuo._id,
        title: chuangZuo.title,
        content: chuangZuo.content,
        tuavatar: chuangZuo.tuavatar,
        shjian: chuangZuo.shjian,
        fabu: chuangZuo.fabu,
        redu: chuangZuo.redu,
        weiid: chuangZuo.weiid,
        tuavatarBase64,
        user: {
          _id: user._id,
          username: user.username,
          dengj: user.dengj,
          sex: user.sex,
          avatar: user.avatar,
          createdAt: user.createdAt,
        },
      };
    }));

    // 返回所有创作的信息，包括图片的 Base64 格式和关联的用户信息
    res.status(200).json(chuangZuoWithBase64AndUser);
  } catch (error) {
    // 捕捉任何错误并返回500内部服务器错误
    console.error(error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});

// 获取图片的 Base64 数据
function getBase64FromImagePath(imagePath) {
  return new Promise((resolve, reject) => {
    fs.readFile(imagePath, (err, data) => {
      if (err) {
        reject(err);
      } else {
        resolve(data.toString('base64'));
      }
    });
  });
}












// 查询所有用户，单纯的查询所有用户,返回没有头像，还没写完，就是单纯返回的是所有用户单没头像，估计用不到，用了再写
router.get('/getUsers', async (req, res) => {
  try {
    const allUsers = await userSchemaModel.find();
    res.status(200).json(allUsers);
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});



// 查询某个创作下的所有章节，返回的信息也有对应weiid的内容
router.get('/getZhangJieByChuangZuoId/:chuangZuoId', async (req, res) => {
  try {
    const { chuangZuoId } = req.params;

    const allZhangJie = await zhangJieModel
      .find({ weiid: chuangZuoId })
      .populate('weiid');

    res.status(200).json(allZhangJie);
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});



// 查询某个小说下的所有章节，只会返回章节，和内容chuangZuoId是小说的id，和上面的差不多，可以跑一下试试，看看有没有你想要的信息
router.get('/getZhangJiexiao/:chuangZuoId', async (req, res) => {
  try {
    const { chuangZuoId } = req.params;
    const allZhangJie = await zhangJieModel
      .find({ weiid: chuangZuoId });

    res.status(200).json(allZhangJie);
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});



// 获取章节内容 ，查询指定章节的内容，估计不用写分页，他是一次性返回一个章节的所有数据，前段写开始阅读的可以使用分割来写                    
// 演示http://localhost:3000/sne/getZhangJieneirong/659e0f41bee25d7d88bda176?shu=第二章-开学
// 这要是没有 ?shu=第二章-开学 ，他默认返回所有对应小说的所有章节
router.get('/getZhangJieneirong/:chuangZuoId', async (req, res) => {
  try {
    const { chuangZuoId } = req.params;
    const { shu } = req.query; // 从查询参数获取 shu

    // 构建查询条件
    const query = { weiid: chuangZuoId };
    if (shu) {
      // 如果提供了 shu 查询参数，添加到查询条件中
      query.shu = shu;
    }

    // 执行查询
    const allZhangJie = await zhangJieModel.find(query);

    res.status(200).json(allZhangJie);
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});


// 搜索接口，用于首页的模糊搜索，搜的是小说名字，这个返回的数据没头像，想要的跟我说一下，或者你根据返回的小说id在调用getallBookInfo这个接口
// 搜索接口，用于首页的模糊搜索，搜的是小说名字，这个返回的数据没头像，想要的跟我说一下，或者你根据返回的小说id在调用getallBookInfo这个接口
router.get('/search/:keyword', async (req, res) => {
  try {
    const keyword = req.params.keyword;
    
    // 使用正则表达式进行模糊搜索
    const searchResults = await chuangZuoSchemaModel.find({ title: { $regex: keyword, $options: 'i' } });

    // 构建包含小说信息及头像二进制数据的响应对象
    const responseArray = [];

    for (const chuangZuo of searchResults) {
      const responseObj = {
        _id: chuangZuo._id,
        title: chuangZuo.title,
        content: chuangZuo.content,
        shjian: chuangZuo.shjian,
        fabu: chuangZuo.fabu,
        redu: chuangZuo.redu,
      };

      // 如果小说有头像，则添加头像二进制数据到响应对象
      if (chuangZuo.tuavatar) {
        const imagePath = path.join(__dirname, '..', 'img', 'shu', chuangZuo.tuavatar);
        const imageBuffer = fs.readFileSync(imagePath);
        responseObj.tuavatarImage = imageBuffer;
      }

      responseArray.push(responseObj);
    }

    res.status(200).json(responseArray);
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});




// 修改小说介绍标题等信息接口
router.put('/updateChuangZuo/:chuangZuoId', async (req, res) => {
  try {
    const { chuangZuoId } = req.params;
    const updateFields = req.body; // 从请求体获取要更新的字段

    // 尝试更新小说信息
    const updatedChuangZuo = await chuangZuoSchemaModel.findByIdAndUpdate(
      chuangZuoId,
      { $set: updateFields },
      { new: true }
    );

    // 检查小说是否存在
    if (!updatedChuangZuo) {
      return res.status(404).json({ error: '小说不存在' });
    }

    res.status(200).json(updatedChuangZuo);
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});


// 书架，要求传用户id和书架的id
router.post('/collectBook/:userId/:chuangZuoId', async (req, res) => {
  try {
      const { userId, chuangZuoId } = req.params;

      // 检查用户和图书是否存在
      const user = await userSchemaModel.findById(userId);
      const chuangZuo = await chuangZuoSchemaModel.findById(chuangZuoId);

      if (!user || !chuangZuo) {
          return res.status(404).json({ error: '用户或图书不存在' });
      }

      // 更新用户的 collections 数组，添加收藏的图书
      user.collections.push(chuangZuoId);
      await user.save();

      res.status(200).json({ success: true });
  } catch (error) {
      console.error(error);
      res.status(500).json({ error: 'Internal Server Error' });
  }
});



// 查询用户收藏的图书
router.get('/getUserShoucangs/:userId', async (req, res) => {
  try {
    const { userId } = req.params;

    // 查询用户信息，包括收藏的图书ID数组
    const user = await userSchemaModel.findById(userId).select('collections');

    if (!user) {
      return res.status(404).json({ error: '用户不存在' });
    }

    // 获取用户收藏的图书ID数组
    const collections = user.collections || [];

    // 查询收藏的图书信息
    const shoucangBooks = await chuangZuoSchemaModel.find({ _id: { $in: collections } });

    res.status(200).json(shoucangBooks);
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});


//查询用户创作的图书，返回没有图片，着急的建议找上面的接口getallBookInfo只需要传小说id就行，或者等我写完
router.get('/getAllChuangZUser/:userId', async (req, res) => {
  console.log('触发根据用户查询所有创作接口');
  try {
    const { userId } = req.params;

    // 查询数据库中所有创作，过滤出指定用户的创作
    const userChuangZuo = await chuangZuoSchemaModel.find({ weiid: userId });

    // 返回指定用户的所有创作的信息
    res.status(200).json(userChuangZuo);
  } catch (error) {
    // 捕捉任何错误并返回500内部服务器错误
    console.error(error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});



// 获取图书封面的接口，根据小说的id获取对应的图片，没有其他多余的信息，这没什么用就是返回的图片
router.get('/getBookCover/:chuangZuoId', async (req, res) => {
  try {
    const { chuangZuoId } = req.params;

    // 根据创作ID查找数据库，获取图书封面路径
    const chuangZuo = await chuangZuoSchemaModel.findById(chuangZuoId);

    if (!chuangZuo || !chuangZuo.tuavatar) {
      return res.status(404).json({ error: '图书封面不存在' });
    }
    const imagePath = path.join(__dirname, '..', 'img', 'shu', chuangZuo.tuavatar);
    console.log('Image Path:', imagePath);
    const imageBuffer = fs.readFileSync(imagePath);
    res.setHeader('Content-Type', 'image/jpeg');
    res.send(imageBuffer);
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});




// 获取图书封面及创作信息的接口，获取指定的小说，这个跟getallallChuangZuo接口不一样，他返回的不光有图片还有用户信息，getallallChuangZuo返回的是所有，没有过滤

router.get('/getallBookInfo/:chuangZuoId', async (req, res) => {
  try {
    const { chuangZuoId } = req.params;

    // 根据创作ID查找数据库，获取创作信息
    const chuangZuo = await chuangZuoSchemaModel.findById(chuangZuoId);

    if (!chuangZuo || !chuangZuo.tuavatar) {
      return res.status(404).json({ error: '创作信息不存在或图书封面不存在' });
    }

    // 构建图书封面的完整路径
    const imagePath = path.join(__dirname, '..', 'img', 'shu', chuangZuo.tuavatar);

    // 读取图像文件的二进制数据
    const imageBuffer = fs.readFileSync(imagePath);

    // 查询关联表获取关联信息
    const relatedInfo = await userSchemaModel.findById(chuangZuo.weiid);

    // 将需要返回的创作信息字段和关联信息添加到响应对象中
    const responseObj = {
      title: chuangZuo.title,
      content: chuangZuo.content,
      shjian: chuangZuo.shjian,
      fabu: chuangZuo.fabu,
      redu: chuangZuo.redu,
      weiid: {
        _id: relatedInfo._id,
        username: relatedInfo.username,
        sex:relatedInfo.sex,
        dengj:relatedInfo.dengj
        // 添加关联表的其他字段
        // 例如：name: relatedInfo.name
      },
      _id: chuangZuo._id,
    };
    res.status(200).json({ success: true, message: 'Success', data: responseObj, image: imageBuffer });
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: '内部服务器错误' });
  }
});



// 完整的添加小说接口，可以上传图片的吗，不光要有上传的图片还要有信息，这个接口有点复杂，建议低头向右看
// 并高喊森哥，或等我写个所有接口的使用说明，反正你们也用不到这个接口
// 这个你们一般用不到，要是认为数据库的数据不够，你可以用这个接口添加数据，
router.post('/upload', async (req, res) => {
  console.log("触发添加");
  try {
    console.log(req.files);   
    if (!req.files || Object.keys(req.files).length === 0) {
      return res.status(400).json({ error: '没有上传文件' });
    }
    const sampleFile = req.files.sampleFile;
    const fileNameWithoutExtension = sampleFile.name.split('.')[0];
    const fileExtension = sampleFile.name.split('.').pop();
    // 生成时间戳和随机字符串
    const timestamp = new Date().getTime();
    const randomString = Math.random().toString(36).substring(7);
    const newFileName = `${fileNameWithoutExtension}_${timestamp}_${randomString}.${fileExtension}`;
    const filePath = `./img/shu/${newFileName}`;

    // 创建目标文件夹，如果不存在的话
    const folderPath = path.dirname(filePath);
    if (!fs.existsSync(folderPath)) {
      try {
        fs.mkdirSync(folderPath, { recursive: true });
      } catch (mkdirError) {
        return res.status(500).json({ error: mkdirError.message });
      }
    }

    // 保存文件到服务器
    sampleFile.mv(filePath, async (err) => {
      if (err) {
        return res.status(500).json({ error: err.message });
      }
      const newChuangZuo = new chuangZuoSchemaModel({
        title: req.body.title,
        content: req.body.content,
        tuavatar: newFileName,
        shjian: req.body.shjian,
        fabu: req.body.fabu,
        redu: req.body.redu,
        weiid: new mongoose.Types.ObjectId(req.body.userId),
      });

      await newChuangZuo.save();

      res.json({ success: true, message: '文件上传创作添加成功!' });
    });
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: '内部服务器错误' });
  }
});



// 查不多就是这么多接口，想要什么返回数据群里说一下我写一下，接口我测试的是都能跑桶
// 如果图片不显示建议看看获取展示下的展示，原理差不多，百度一搜就有，
// 后端返回的图片是2进制数据，你要是嫌麻烦，(可以写假的)

// 还有就是，你们添加的时候注意一下，添加用户无所谓，但是添加图书的时候注意weiid这个字段要写一个用户的_id，这表明这个小说是这个用户创建的
// 然后就是tuavatar图片，你们用postman不会的话，百度或者叫我
// 如果想要添加章节weiid这个写的是小说的_id，不要为空，不然你查不出来
module.exports = router;
